package vg.services.graph_view_manager.interfaces.graph_comparison;

import com.google.common.collect.BiMap;
import vg.services.data_base_manager.data.graph.Edge;
import vg.services.data_base_manager.data.graph.Graph;
import vg.services.data_base_manager.data.graph.Vertex;

import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

/**
 * Output properties for graph comparison algorithm.
 *
 * @author Timur Zolotuhin (e-mail: tzolotuhin@gmail.com)
 */
public class OutputGraphComparisonAlgorithmProperties {
    private Graph maximalCommonSubgraph;
    private Graph firstGraph;
    private Graph secondGraph;

    private BiMap<Vertex, Vertex> outputGraphVertices2firstOriginalGraphVertices;
    private BiMap<Vertex, Vertex> outputGraphVertices2secondOriginalGraphVertices;

    private List<Vertex> firstGraphVertexOutsiders;
    private List<Vertex> secondGraphVertexOutsiders;
    private List<Edge> firstGraphEdgeOutsiders;
    private List<Edge> secondGraphEdgeOutsiders;

    private Map<String, Float> vertexAttributeAndWeightTable;
    private Map<String, Float> edgeAttributeAndWeightTable;

    private float vertexBarrier;
    private float edgeBarrier;

    private float[][] vertexMatchingTable;
    private float[][] edgeMatchingTable;

    private float[][] heuristicVertexMatchingTable;
    private float[][] heuristicEdgeMatchingTable;

    private int firstGraphVertexCount;
    private int firstGraphEdgeCount;

    private int secondGraphVertexCount;
    private int secondGraphEdgeCount;

    private Map<Vertex, Integer> firstGraphVertex2Index;
    private Map<Vertex, Integer> secondGraphVertex2Index;

    private Map<Integer, Vertex> firstGraphIndex2Vertex;
    private Map<Integer, Vertex> secondGraphIndex2Vertex;

    private Map<Vertex, Integer> firstGraphEdge2Index;
    private Map<Vertex, Integer> secondGraphEdge2Index;

    private Map<Integer, Vertex> firstGraphIndex2Edge;
    private Map<Integer, Vertex> secondGraphIndex2Edge;

    private BigDecimal upperBoundCountCases;
    private BigDecimal upperBoundHeuristicCountCases;

    public Map<String, Float> getVertexAttributeAndWeightTable() {
        return vertexAttributeAndWeightTable;
    }

    public Map<String, Float> getEdgeAttributeAndWeightTable() {
        return edgeAttributeAndWeightTable;
    }

    public float getVertexBarrier() {
        return vertexBarrier;
    }

    public float getEdgeBarrier() {
        return edgeBarrier;
    }

    public float[][] getVertexMatchingTable() {
        return vertexMatchingTable;
    }

    public float[][] getEdgeMatchingTable() {
        return edgeMatchingTable;
    }

    public float[][] getHeuristicVertexMatchingTable() {
        return heuristicVertexMatchingTable;
    }

    public float[][] getHeuristicEdgeMatchingTable() {
        return heuristicEdgeMatchingTable;
    }

    public Map<Vertex, Integer> getFirstGraphVertex2Index() {
        return firstGraphVertex2Index;
    }

    public Map<Vertex, Integer> getSecondGraphVertex2Index() {
        return secondGraphVertex2Index;
    }

    public Map<Integer, Vertex> getFirstGraphIndex2Vertex() {
        return firstGraphIndex2Vertex;
    }

    public Map<Integer, Vertex> getSecondGraphIndex2Vertex() {
        return secondGraphIndex2Vertex;
    }

    public int getFirstGraphVertexCount() {
        return firstGraphVertexCount;
    }

    public int getFirstGraphEdgeCount() {
        return firstGraphEdgeCount;
    }

    public int getSecondGraphVertexCount() {
        return secondGraphVertexCount;
    }

    public int getSecondGraphEdgeCount() {
        return secondGraphEdgeCount;
    }

    public BigDecimal getUpperBoundCountCases() {
        return upperBoundCountCases;
    }

    public BigDecimal getUpperBoundHeuristicCountCases() {
        return upperBoundHeuristicCountCases;
    }

    public Map<Vertex, Integer> getFirstGraphEdge2Index() {
        return firstGraphEdge2Index;
    }

    public Map<Vertex, Integer> getSecondGraphEdge2Index() {
        return secondGraphEdge2Index;
    }

    public Map<Integer, Vertex> getFirstGraphIndex2Edge() {
        return firstGraphIndex2Edge;
    }

    public Map<Integer, Vertex> getSecondGraphIndex2Edge() {
        return secondGraphIndex2Edge;
    }

    public Graph getMaximalCommonSubgraph() {
        return maximalCommonSubgraph;
    }

    public Graph getFirstGraph() {
        return firstGraph;
    }

    public Graph getSecondGraph() {
        return secondGraph;
    }

    public List<Vertex> getFirstGraphVertexOutsiders() {
        return firstGraphVertexOutsiders;
    }

    public List<Vertex> getSecondGraphVertexOutsiders() {
        return secondGraphVertexOutsiders;
    }

    public List<Edge> getFirstGraphEdgeOutsiders() {
        return firstGraphEdgeOutsiders;
    }

    public List<Edge> getSecondGraphEdgeOutsiders() {
        return secondGraphEdgeOutsiders;
    }

    public BiMap<Vertex, Vertex> getOutputGraphVertices2firstOriginalGraphVertices() {
        return outputGraphVertices2firstOriginalGraphVertices;
    }

    public BiMap<Vertex, Vertex> getOutputGraphVertices2secondOriginalGraphVertices() {
        return outputGraphVertices2secondOriginalGraphVertices;
    }

    public void setVertexAttributeAndWeightTable(Map<String, Float> vertexAttributeAndWeightTable) {
        this.vertexAttributeAndWeightTable = vertexAttributeAndWeightTable;
    }

    public void setEdgeAttributeAndWeightTable(Map<String, Float> edgeAttributeAndWeightTable) {
        this.edgeAttributeAndWeightTable = edgeAttributeAndWeightTable;
    }

    public void setVertexBarrier(float vertexBarrier) {
        this.vertexBarrier = vertexBarrier;
    }

    public void setEdgeBarrier(float edgeBarrier) {
        this.edgeBarrier = edgeBarrier;
    }

    public void setVertexMatchingTable(float[][] vertexMatchingTable) {
        this.vertexMatchingTable = vertexMatchingTable;
    }

    public void setEdgeMatchingTable(float[][] edgeMatchingTable) {
        this.edgeMatchingTable = edgeMatchingTable;
    }

    public void setHeuristicVertexMatchingTable(float[][] heuristicVertexMatchingTable) {
        this.heuristicVertexMatchingTable = heuristicVertexMatchingTable;
    }

    public void setHeuristicEdgeMatchingTable(float[][] heuristicEdgeMatchingTable) {
        this.heuristicEdgeMatchingTable = heuristicEdgeMatchingTable;
    }

    public void setFirstGraphVertex2Index(Map<Vertex, Integer> firstGraphVertex2Index) {
        this.firstGraphVertex2Index = firstGraphVertex2Index;
    }

    public void setSecondGraphVertex2Index(Map<Vertex, Integer> secondGraphVertex2Index) {
        this.secondGraphVertex2Index = secondGraphVertex2Index;
    }

    public void setFirstGraphIndex2Vertex(Map<Integer, Vertex> firstGraphIndex2Vertex) {
        this.firstGraphIndex2Vertex = firstGraphIndex2Vertex;
    }

    public void setSecondGraphIndex2Vertex(Map<Integer, Vertex> secondGraphIndex2Vertex) {
        this.secondGraphIndex2Vertex = secondGraphIndex2Vertex;
    }

    public void setFirstGraphVertexCount(int firstGraphVertexCount) {
        this.firstGraphVertexCount = firstGraphVertexCount;
    }

    public void setFirstGraphEdgeCount(int firstGraphEdgeCount) {
        this.firstGraphEdgeCount = firstGraphEdgeCount;
    }

    public void setSecondGraphVertexCount(int secondGraphVertexCount) {
        this.secondGraphVertexCount = secondGraphVertexCount;
    }

    public void setSecondGraphEdgeCount(int secondGraphEdgeCount) {
        this.secondGraphEdgeCount = secondGraphEdgeCount;
    }

    public void setUpperBoundCountCases(BigDecimal upperBoundCountCases) {
        this.upperBoundCountCases = upperBoundCountCases;
    }

    public void setUpperBoundHeuristicCountCases(BigDecimal upperBoundHeuristicCountCases) {
        this.upperBoundHeuristicCountCases = upperBoundHeuristicCountCases;
    }

    public void setFirstGraphEdge2Index(Map<Vertex, Integer> firstGraphEdge2Index) {
        this.firstGraphEdge2Index = firstGraphEdge2Index;
    }

    public void setSecondGraphEdge2Index(Map<Vertex, Integer> secondGraphEdge2Index) {
        this.secondGraphEdge2Index = secondGraphEdge2Index;
    }

    public void setFirstGraphIndex2Edge(Map<Integer, Vertex> firstGraphIndex2Edge) {
        this.firstGraphIndex2Edge = firstGraphIndex2Edge;
    }

    public void setSecondGraphIndex2Edge(Map<Integer, Vertex> secondGraphIndex2Edge) {
        this.secondGraphIndex2Edge = secondGraphIndex2Edge;
    }

    public void setMaximalCommonSubgraph(Graph maximalCommonSubgraph) {
        this.maximalCommonSubgraph = maximalCommonSubgraph;
    }

    public void setFirstGraph(Graph firstGraph) {
        this.firstGraph = firstGraph;
    }

    public void setSecondGraph(Graph secondGraph) {
        this.secondGraph = secondGraph;
    }

    public void setFirstGraphVertexOutsiders(List<Vertex> firstGraphVertexOutsiders) {
        this.firstGraphVertexOutsiders = firstGraphVertexOutsiders;
    }

    public void setSecondGraphVertexOutsiders(List<Vertex> secondGraphVertexOutsiders) {
        this.secondGraphVertexOutsiders = secondGraphVertexOutsiders;
    }

    public void setFirstGraphEdgeOutsiders(List<Edge> firstGraphEdgeOutsiders) {
        this.firstGraphEdgeOutsiders = firstGraphEdgeOutsiders;
    }

    public void setSecondGraphEdgeOutsiders(List<Edge> secondGraphEdgeOutsiders) {
        this.secondGraphEdgeOutsiders = secondGraphEdgeOutsiders;
    }

    public void setOutputGraphVertices2firstOriginalGraphVertices(BiMap<Vertex, Vertex> outputGraphVertices2firstOriginalGraphVertices) {
        this.outputGraphVertices2firstOriginalGraphVertices = outputGraphVertices2firstOriginalGraphVertices;
    }

    public void setOutputGraphVertices2secondOriginalGraphVertices(BiMap<Vertex, Vertex> outputGraphVertices2secondOriginalGraphVertices) {
        this.outputGraphVertices2secondOriginalGraphVertices = outputGraphVertices2secondOriginalGraphVertices;
    }
}
